home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / iso9660 / ip / manage / snmp / patches.shr / parse.c.diff < prev    next >
Encoding:
Text File  |  1992-01-15  |  7.9 KB  |  359 lines
  1. ===================================================================
  2. RCS file: /s/usr2/K/repo/tools/cmu-snmp/snmplib/parse.c,v
  3. retrieving revision 1.1
  4. diff -c -r1.1 parse.c
  5. *** /tmp/,RCSt1a22340    Tue Sep 24 20:22:59 1991
  6. --- parse.c    Thu Sep 19 06:18:15 1991
  7. ***************
  8. *** 1,3 ****
  9. --- 1,4 ----
  10. + /* $Id: parse.c,v 1.3 91/09/19 06:18:33 phil Exp $    */
  11.   /***********************************************************
  12.       Copyright 1989 by Carnegie Mellon University
  13.   
  14. ***************
  15. *** 69,74 ****
  16. --- 70,80 ----
  17.   #define RECOMMENDED 26
  18.   #define PUNCT        27
  19.   #define EQUALS        28
  20. + #define DESCRIPTION 29
  21. + #define QUOTESTRING 30
  22. + #define INDEX        31
  23. + #define DEFVAL        32
  24. + #define DEPRECATED  33
  25.   
  26.   struct tok {
  27.       char *name;            /* token name */
  28. ***************
  29. *** 113,121 ****
  30. --- 119,132 ----
  31.       { "{", sizeof ("{")-1, PUNCT },
  32.       { "}", sizeof ("}")-1, PUNCT },
  33.       { "::=", sizeof ("::=")-1, EQUALS },
  34. +         { "DESCRIPTION", sizeof ("DESCRIPTION")-1, DESCRIPTION },
  35. +         { "INDEX", sizeof ("INDEX")-1, INDEX },
  36. +         { "DEFVAL", sizeof ("DEFVAL")-1, DEFVAL },
  37. +     { "deprecated", sizeof ("deprecated")-1, DEPRECATED },
  38.       { NULL }
  39.   };
  40.   
  41. + 
  42.   #define    HASHSIZE    32
  43.   #define    BUCKET(x)    (x & 0x01F)
  44.   
  45. ***************
  46. *** 341,347 ****
  47.   {
  48.       register int count;
  49.       int type;
  50. !     char token[64], label[32];
  51.       register char *cp, *tp;
  52.   
  53.       if ((type = get_token(fp, token)) != PUNCT){
  54. --- 352,358 ----
  55.   {
  56.       register int count;
  57.       int type;
  58. !     char token[MAXTOKEN], label[MAXLABEL];
  59.       register char *cp, *tp;
  60.   
  61.       if ((type = get_token(fp, token)) != PUNCT){
  62. ***************
  63. *** 430,436 ****
  64.       char *name;
  65.   {
  66.       int type;
  67. !     char token[64];
  68.       register int count;
  69.       register struct subid *op, *nop;
  70.       int length;
  71. --- 441,447 ----
  72.       char *name;
  73.   {
  74.       int type;
  75. !     char token[MAXTOKEN];
  76.       register int count;
  77.       register struct subid *op, *nop;
  78.       int length;
  79. ***************
  80. *** 516,526 ****
  81.       FILE *fp;
  82.   {
  83.       int type;
  84. !     char token[64];
  85.   
  86.       type = get_token(fp, token);
  87.       if (type != SEQUENCE){
  88. !     print_error("Not a sequence", (char *)NULL); /* should we handle this */
  89.       return NULL;
  90.       }
  91.       while((type = get_token(fp, token)) != NULL){
  92. --- 527,537 ----
  93.       FILE *fp;
  94.   {
  95.       int type;
  96. !     char token[MAXTOKEN];
  97.   
  98.       type = get_token(fp, token);
  99.       if (type != SEQUENCE){
  100. !     type = get_token(fp, token);
  101.       return NULL;
  102.       }
  103.       while((type = get_token(fp, token)) != NULL){
  104. ***************
  105. *** 543,554 ****
  106.       char *name;
  107.   {
  108.       register int type;
  109. !     char token[64];
  110.       int count, length;
  111.       struct subid oid[16];
  112. !     char syntax[32];
  113.       int nexttype;
  114. !     char nexttoken[64];
  115.       register struct node *np;
  116.       register struct enum_list *ep;
  117.       register char *cp;
  118. --- 554,565 ----
  119.       char *name;
  120.   {
  121.       register int type;
  122. !     char token[MAXTOKEN];
  123.       int count, length;
  124.       struct subid oid[16];
  125. !     char syntax[MAXTOKEN];
  126.       int nexttype;
  127. !     char nexttoken[MAXTOKEN];
  128.       register struct node *np;
  129.       register struct enum_list *ep;
  130.       register char *cp;
  131. ***************
  132. *** 706,717 ****
  133.       return 0;
  134.       }
  135.       type = get_token(fp, token);
  136. !     if (type != MANDATORY && type != OPTIONAL && type != OBSOLETE && type != RECOMMENDED){
  137.       print_error("Bad status", token);
  138.       free_node(np);
  139.       return 0;
  140.       }
  141.       type = get_token(fp, token);
  142.       if (type != EQUALS){
  143.       print_error("Bad format", token);
  144.       free_node(np);
  145. --- 717,760 ----
  146.       return 0;
  147.       }
  148.       type = get_token(fp, token);
  149. !     if (type != MANDATORY && type != OPTIONAL && type != OBSOLETE && type != RECOMMENDED && type != DEPRECATED){
  150.       print_error("Bad status", token);
  151.       free_node(np);
  152.       return 0;
  153.       }
  154.       type = get_token(fp, token);
  155. +     /*
  156. +      * Optional parts of the OBJECT-TYPE macro
  157. +      */
  158. +     while (type != EQUALS) {
  159. +     int breakFlag = 0;
  160. +     switch (type) {
  161. +       case DESCRIPTION:
  162. +         type = get_token(fp, token);
  163. +         if (type != QUOTESTRING) {
  164. +         print_error("Bad DESCRIPTION", token);
  165. +         free_node(np);
  166. +         return 0;
  167. +         }
  168. +         break;
  169. + 
  170. +       case INDEX:
  171. +       case DEFVAL:
  172. +         if (tossObjectIdentifier(fp, token) != OBJID) {
  173. +         print_error("Bad Object Identifier", token);
  174. +         free_node(np);
  175. +         return 0;
  176. +         }
  177. +         break;
  178. + 
  179. +       default:
  180. +         print_error("Bad format of optional clauses", token);
  181. +         free_node(np);
  182. +         return 0;
  183. +         break;
  184. +     }
  185. +     type = get_token(fp, token);
  186. +     }
  187.       if (type != EQUALS){
  188.       print_error("Bad format", token);
  189.       free_node(np);
  190. ***************
  191. *** 721,727 ****
  192.       if (length > 1 && length <= 16){
  193.       /* just take the last pair in the oid list */
  194.       if (oid[length - 2].label)
  195. !         strncpy(np->parent, oid[length - 2].label, 32);
  196.       strcpy(np->label, name);
  197.       if (oid[length - 1].subid != -1)
  198.           np->subid = oid[length - 1].subid;
  199. --- 764,770 ----
  200.       if (length > 1 && length <= 16){
  201.       /* just take the last pair in the oid list */
  202.       if (oid[length - 2].label)
  203. !         strncpy(np->parent, oid[length - 2].label, MAXLABEL);
  204.       strcpy(np->label, name);
  205.       if (oid[length - 1].subid != -1)
  206.           np->subid = oid[length - 1].subid;
  207. ***************
  208. *** 750,757 ****
  209.   parse(fp)
  210.       FILE *fp;
  211.   {
  212. !     char token[64];
  213. !     char name[32];
  214.       int    type = 1;
  215.       struct node *np, *root = NULL;
  216.   
  217. --- 793,800 ----
  218.   parse(fp)
  219.       FILE *fp;
  220.   {
  221. !     char token[MAXTOKEN];
  222. !     char name[MAXLABEL];
  223.       int    type = 1;
  224.       struct node *np, *root = NULL;
  225.   
  226. ***************
  227. *** 766,772 ****
  228.           print_error(token, "is a reserved word");
  229.           return NULL;
  230.       }
  231. !     strncpy(name, token, 32);
  232.       type = get_token(fp, token);
  233.       if (type == OBJTYPE){
  234.           if (root == NULL){
  235. --- 809,815 ----
  236.           print_error(token, "is a reserved word");
  237.           return NULL;
  238.       }
  239. !     strncpy(name, token, MAXTOKEN);
  240.       type = get_token(fp, token);
  241.       if (type == OBJTYPE){
  242.           if (root == NULL){
  243. ***************
  244. *** 806,811 ****
  245. --- 849,859 ----
  246.           np = np->next;
  247.       } else if (type == EQUALS){
  248.           type = parse_asntype(fp);
  249. +         if (type != NULL) {
  250. +         /* equivalenced type: DdpAddress :== OCTET STRING */
  251. +         /* What to do?  */
  252. +         }
  253. +         
  254.       } else if (type == NULL){
  255.           break;
  256.       } else {
  257. ***************
  258. *** 813,818 ****
  259. --- 861,867 ----
  260.           return NULL;
  261.       }
  262.       }
  263. +     
  264.   #ifdef TEST
  265.   {
  266.       struct enum_list *ep;
  267. ***************
  268. *** 854,859 ****
  269. --- 903,910 ----
  270.       ch = getc(fp);
  271.       if (ch == '\n')
  272.           Line++;
  273. +     else if (ch == '"')
  274. +         return parseQuoteString(fp, token);
  275.       }
  276.       if (ch == -1)
  277.       return NULL;
  278. ***************
  279. *** 900,905 ****
  280. --- 951,1028 ----
  281.       
  282.       } while ((ch = getc(fp)) != -1);
  283.       return NULL;
  284. + }
  285. + 
  286. + static int
  287. + parseQuoteString(fp, token)
  288. +     register FILE *fp;
  289. +     register char *token;
  290. + {
  291. +     static char last = ' ';
  292. +     register int ch;
  293. +     register char *cp = token;
  294. +     register int hash = 0;
  295. +     register struct tok *tp;
  296. + 
  297. +     ch = ' ';
  298. +     
  299. +     while(ch != -1) {
  300. +     ch = getc(fp);
  301. +     cp++;
  302. +     
  303. +     if (ch == '\n')
  304. +         Line++;
  305. +     else if (ch == '"') {
  306. +         return QUOTESTRING;
  307. +     }
  308. +     }
  309. +     if (ch == -1) {
  310. +     last = ch;
  311. +     *cp = '\0';
  312. +     return NULL;
  313. +     }
  314. + }
  315. + 
  316. + /*
  317. +  * This routine parses a string like  { blah blah blah } and returns OBJID if
  318. +  * it is well formed, and NULL if not.
  319. +  */ 
  320. + static int
  321. + tossObjectIdentifier(fp, token)
  322. +     register FILE *fp;
  323. +     register char *token;
  324. + {
  325. +     static char last = ' ';
  326. +     register int ch;
  327. +     register char *cp = token;
  328. +     register int hash = 0;
  329. +     register struct tok *tp;
  330. + 
  331. + 
  332. +     ch = last;
  333. +     /* skip all white space */
  334. +     while(isspace(ch) && ch != -1){
  335. +     ch = getc(fp);
  336. +     if (ch == '\n')
  337. +         Line++;
  338. +     }
  339. +     if (ch != '{')
  340. +     return NULL;
  341. +     
  342. +     while(ch != -1) {
  343. +     ch = getc(fp);
  344. +     cp++;
  345. +     
  346. +     if (ch == '\n')
  347. +         Line++;
  348. +     else if (ch == '}')
  349. +         return OBJID;
  350. +     }
  351. +     if (ch == -1){
  352. +     last = ch;
  353. +     *cp = '\0';
  354. +     return NULL;
  355. +     }
  356.   }
  357.   
  358.   struct tree *
  359.